Rewriting Guarded Existential Rules into Small Datalog Programs

The goal of this paper is to understand the relative expressiveness of the query language in which queries are specified by a set of guarded (disjunctive) tuple-generating dependencies (TGDs) and an output (or \u27answer\u27) predicate. Our main result is to show that every such query can be translated into a polynomially-sized (disjunctive) Datalog program if the maximal number of variables in the (disjunctive) TGDs is bounded by a constant. To overcome the challenge that Datalog has no direct means to express the existential quantification present in TGDs, we define a two-player game that characterizes the satisfaction of the dependencies, and design a Datalog query that can decide the existence of a winning strategy for the game. For guarded disjunctive TGDs, we can obtain Datalog rules with disjunction in the heads. However, the use of disjunction is limited, and the resulting rules fall into a fragment that can be evaluated in deterministic single exponential time. We proceed quite differently for the case when the TGDs are not disjunctive and we show that we can obtain a plain Datalog query. Notably, unlike previous translations for related fragments, our translation requires only polynomial time if the maximal number of variables in the (disjunctive) TGDs is bounded by a constant

Rewriting approaches for ontology-mediated query answering

Zusammenfassung in deutscher SpracheOntology-based data access (OBDA, for short) aims to facilitate the access to inherently incomplete and heterogeneous data sources and to retrieve more complete answers by means of an intermediate layer that conceptualizes the domain of interest, known as anontology. The OBDA paradigm is regarded as a key ingredient in modern information management systems, receiving tremendous attention over the past decade. Crucial to OBDA is the problem of answering user queries by taking into account the background knowledge provided by the ontology, viewing the query and the ontology as part of a composite query, called ontology-mediated query (OMQ). We refer to this problem as ontology-mediated query answering (OMQA). To make OMQA scale to large amounts of data and to be useful in practice, OMQA relies on converting the problem of answering OMQs to the problem of evaluating the query directly over the data. This is referred to as OMQ rewriting and is considered to be one of the most promising approaches for OMQA, as it allows for the exploitation of standard database management systems.Despite the fact that OMQA has been a subject of in-depth study in the database and KR research communities over the last decade, there are many challenges that remain to be addressed. In particular, several extensions of the components of the OMQA framework have been considered in order to enhance its expressive power and the application domain. We study three particular ways that enrich OMQA: the database is viewed as partially complete through closed predicates, the ontology languages are given in terms of expressive description logics (DLs) and guarded (disjunctive) tuple-generating dependencies (DTGDs), and the query language is given in terms of a fragment of SPARQL, the standard query language for the Semantic Web. The goal of this thesis is to investigate OMQA in the presence of such extensions and to explore novel rewriting techniques, with the emphasis on polynomial time rewritings. First, we develop a novel and versatile rewriting technique, which can be suitably extended and adapted for various OMQ languages, enabling polynomial time rewritings into variants of Datalog. By employing this technique we present a polynomial time rewriting for the DL ALCHOI in the presence of partial completeness of the database and a restricted class of conjunctive queries (CQs) into Datalog with stable negation.We then adapt it to support guarded DTGDs and a restricted class of CQs. We show that every such OMQ can be translated into a polynomially-sized Datalog program with disjunction (without negation) if the arity of the predicates and number of variables in the DTGDs is bounded by a constant; for non-disjunctive TGDs the rewriting is a plain Datalog program. To the best of our knowledge, these are the first such rewritings that are polynomial. We then study a fragment of SPARQL, called well-designed SPARQL, which extends conjunctive queries with a special operator. In recent years, SPARQL has been widely adopted as a query language for OMQA. However, the semantics of query answering under SPARQL entailment regimes is defined in a more naive and much less expressive way than the certain answer semantics usually adopted in OMQA. To bridge this gap, we introduce an intuitive certain answer semantics for SPARQL and present two rewriting approaches that allow us to obtain the certain answers for this fragment and OWL 2 QL, a standardized ontology language based on a lightweight DL.25

Planning in graph databases under description logic constraints

Zsfassung in dt. SpracheGraph databases are gaining increasing importance and they are fundamental for storing, for example, web data in RDF form, but also other forms of semi-structured data. Given the very large amount of data currently available in these stores, efficient management of these data becomes harder and harder. In addition, the development of automated management tools for them is becoming a pressing problem. As in traditional databases, integrity constraints on graph databases are important to capture the semantics of domain of interest. One of the tools to modify this data are transactions. A transaction encapsulates a sequence of modifications to the data which are executed and committed as a unit. Description Logics (DLs) are decidable languages that have been strongly advocated for managing data repositories, for expressing integrity constraints and they are particularly natural for talking about graph databases, as argued in some recent work. A challenging topic is planning in such context. Planning is a classical topic and has been an important problem in Artificial Intelligence for over five decades. In this thesis, we propose a framework for planning in graph databases. To the best of our knowledge, this is the first attempt to formally define planning in such setting. We use an expressive action language that is already defined by an earlier work. This language is expressed through a DL that has the feature to introduce new values to the data. Graph databases are seen as finite DL interpretations. We identify some interesting reasoning tasks, relevant for the setting we consider. The standard one is plan-existence, which corresponds in trying to find a plan for a given instance of a planning problem. We investigate two variants of the problem. The difference between them is that in one of them we do not allow the transactions to introduce fresh constants. We prove that deciding plan-existence for the variation without fresh constants is PSpace-complete. After applying several syntactic restrictions, we are able to determine NlogSpace and NP-hard cases. We are also able to provide several polynomial algorithms for some other cases. In addition, to get some insights to the relationship between our formalism and STRIPS, which is a classical approach to planning, we investigate whether planning in our setting can be reduced to STRIPS. We show that such encoding is possible under some syntactical restrictions. In this way, STRIPS planners can be exploited to solve our planning problem. Furthermore, we study the variation, where the transactions are allowed to introduce fresh constants. Intuitively, this makes planning more involved. We are able to single out some cases in this setting that can be reduced to planning without fresh constants. In this way we prove that those cases are in PSpace.11

Polynomial Datalog Rewritings for Ontology Mediated Queries with Closed Predicates

In ontology-mediated queries (OMQs), a database query is enriched with an ontology, providing knowledge to obtain more complete answers from incomplete data. OMQs are the focus of intensive research, particularly when the ontology is expressed in Description Logics (DLs) or in rule-based formalisms like existential rules and Datalog±, see e.g., BScStud Student, Student ∃attends.Course, BScStud ∀attends.¬GradCourse and the following set of facts A (an ABox ): Course(c 1 ), Course(c 2 ), GradCourse(c 2 ), BScStud(a) The instance query q(x, y) = attends(x, y) mediated by T does not retrieve (a, c 1 ) as a certain answer, but if c 1 and c 2 are known to be the only courses, then we can declare Course a closed predicate, and then (a, c 1 ) becomes a certain answer. We investigate the relative expressiveness of OMQs in terms of more traditional query languages like Datalog. More precisely, we are interested in the following problem: given an OMQ Q (specified by a query and a TBox, possibly with closed predicates), obtain a Datalog query Q -in a suitable fragment-such that, for any ABox A, the certain answers to Q and Q coincide. The existence of such a Q and its size are crucial for understanding the expressive power and succinctness of different families of OMQs. It is also very relevant in practice, since it allows to reuse existing database technologies to support OMQ answering. For example, the research into OMQs that can be rewritten into first-order (FO) queries has produced the successful DL-Lite famil

Polynomial Disjunctive Datalog Rewritings of Instance Queries in Expressive Description Logics

Abstract. Rewriting ontology mediated queries (OMQs) into traditional query languages like FO-queries and Datalog is central for understanding their relative expressiveness, and plays a crucial role in the ongoing efforts to develop OMQ answering tools by reusing existing database technologies. However, the vast majority of works focus on Horn ontologies, and for OMQs where the ontologies are written in extensions of ALC, only a couple of exponential rewritings into disjunctive Datalog are known. In this paper we propose a translation of instance queries mediated by ontologies in the expressive DL ALCHI, into polynomial-sized disjunctive Datalog programs. The translation is based on a simple game-like algorithm, and can be extended to accommodate nominals. We can also rewrite OMQs with closed-predicates into Datalog programs with (limited) negation. Closed predicates are useful for combining complete and incomplete information, but make OMQs non-monotonic and thus not rewritable into positive disjunctive Datalog

Planning Problems for Graph Structured Data in Description Logics ∗

Motivation The complex structure and increasing size of information that has to be managed in today’s applications calls for flexible mechanisms for storing such information, making it easily and efficiently accessible, and facilitating its change and evolution over time. The paradigm of graph structured data (GSD) [5] has gained popularity recently as an alternative to traditional relational databases that provides more flexibility and thus can overcome the limitations of an a priori imposed rigid structure on the data. Indeed, differently from relational data, GSD do not require a schema to be fixed a priori. This flexibility makes them well suited for many emerging application areas such as managing Web data, information integration, persistent storage in object-oriented software development, or management of scientific data. Concrete examples of models for GSD are RDFS [2], object-oriented data models, and XML. Here we build on recent work that advocates the use of Description Logics (DLs) for managing change in GSD that happens as the result of (agents or users) executing actions [4]. We consider GSD understood in a broad sense, as information represented by means of a node and edge labeled graph, in which the labels convey semantic information

Managing Change in Graph-Structured Data Using Description Logics

In this paper we consider the setting of graph-structured data that evolves as a result of operations carried out by users or applications. We study different reasoning problems, which range from ensuring the satisfaction of a given set of integrity constraints after a given sequence of updates, to deciding the (non-)existence of a sequence of actions that would take the data to an (un)desirable state, starting either from a specific data instance or from an incomplete description of it. We consider a simple action language in which actions are finite sequences of insertions and deletions of nodes and labels, and use Description Logics for describing integrity constraints and (partial) states of the data. We then formalize the data management problems mentioned above as a static verification problem and several planning problems. We provide algorithms and tight complexity bounds for the formalized problems, both for an expressive DL and for a variant of DL-Lite

Reconciling SHACL and ontologies : semantics and validation via rewriting

OWL and SHACL are two prominent W3C standards for managing RDF graphs, the data model of the Web. They are used for different purposes and make different assumptions about the completeness of data: SHACL is used for expressing integrity constraints on complete data, while OWL allows inferring implicit facts from incomplete data; SHACL reasoners perform validation, while OWL reasoners do logical inference. Integrating these two tasks into one uniform approach is a relevant but challenging problem. The SHACL standard envisions graph validation in combination with OWL entailment, but it does not provide technical guidance on how to realize this. To address this problem, we propose a new intuitive semantics for validating SHACL constraints with OWL 2 QL ontologies based on a suitable notion of the chase. We propose an algorithm that rewrites a set of recursive SHACL constraints (with stratified negation) and an OWL 2 QL ontology into a stand-alone set of SHACL constraints that preserves validation for every input graph, which can in turn be evaluated using an off-the-shelf SHACL validator. We show that validation in this setting is EXPTIME-complete in combined complexity, but only PTIME-complete in data complexity, i.e., if the constraints and the ontology are fixed